/**
 * 统一的时间处理工具类 - 专为中国用户优化
 * 创建时间: 2025-01-16
 * 目标: 提供一致的、符合中国用户习惯的时间处理功能
 */

/**
 * 获取当前中国本地时间
 */
export function getLocalTime(): Date {
  return new Date()
}

/**
 * 格式化为中国本地日期格式
 * @param date 日期对象或字符串
 * @param format 可选格式参数，支持 'YYYY-MM-DD' 等格式
 * @returns 格式: "2025年1月16日" 或指定格式
 */
export function formatLocalDate(date: string | Date, format?: string): string {
  const localDate = typeof date === 'string' ? new Date(date) : date
  
  if (isNaN(localDate.getTime())) {
    return '无效日期'
  }
  
  // 如果指定了格式，使用自定义格式化
  if (format) {
    if (format === 'YYYY-MM-DD') {
      return localDate.toISOString().split('T')[0]
    }
    if (format === 'YYYY年MM月DD日 HH:mm') {
      return localDate.toLocaleString('zh-CN', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit',
        hour: '2-digit',
        minute: '2-digit',
        hour12: false
      }).replace(/\//g, '年').replace(/\s/, '日 ') + ':00'
    }
  }
  
  return localDate.toLocaleDateString('zh-CN', {
    year: 'numeric',
    month: 'long',
    day: 'numeric'
  })
}

/**
 * 格式化为中国本地时间格式
 * @param date 日期对象或字符串
 * @returns 格式: "下午3:30"
 */
export function formatLocalTime(date: string | Date): string {
  const localDate = typeof date === 'string' ? new Date(date) : date
  
  if (isNaN(localDate.getTime())) {
    return '无效时间'
  }
  
  return localDate.toLocaleTimeString('zh-CN', {
    hour: 'numeric',
    minute: '2-digit',
    hour12: true
  })
}

/**
 * 格式化为中国本地日期时间格式
 * @param date 日期对象或字符串
 * @returns 格式: "2025年1月16日 下午3:30"
 */
export function formatLocalDateTime(date: string | Date): string {
  const localDate = typeof date === 'string' ? new Date(date) : date
  
  if (isNaN(localDate.getTime())) {
    return '无效日期'
  }
  
  return localDate.toLocaleString('zh-CN', {
    year: 'numeric',
    month: 'long',
    day: 'numeric',
    hour: 'numeric',
    minute: '2-digit',
    hour12: true
  })
}

/**
 * 格式化为简短的中国本地日期格式
 * @param date 日期对象或字符串
 * @returns 格式: "1月16日" 或 "2024年1月16日"（跨年显示年份）
 */
export function formatShortDate(date: string | Date): string {
  const localDate = typeof date === 'string' ? new Date(date) : date
  const now = new Date()
  
  if (isNaN(localDate.getTime())) {
    return '无效日期'
  }
  
  // 如果是同一年，不显示年份
  if (localDate.getFullYear() === now.getFullYear()) {
    return localDate.toLocaleDateString('zh-CN', {
      month: 'long',
      day: 'numeric'
    })
  } else {
    return localDate.toLocaleDateString('zh-CN', {
      year: 'numeric',
      month: 'long',
      day: 'numeric'
    })
  }
}

/**
 * 格式化相对时间（多久前/多久后）
 * @param date 日期对象或字符串
 * @returns 格式: "2小时前", "明天", "3天后"
 */
export function formatRelativeTime(date: string | Date): string {
  const localDate = typeof date === 'string' ? new Date(date) : date
  const now = new Date()
  
  if (isNaN(localDate.getTime())) {
    return '无效日期'
  }
  
  const diffMs = localDate.getTime() - now.getTime()
  const diffMinutes = Math.floor(diffMs / (1000 * 60))
  const diffHours = Math.floor(diffMs / (1000 * 60 * 60))
  const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24))
  
  // 过去时间
  if (diffMs < 0) {
    const absDiffMinutes = Math.abs(diffMinutes)
    const absDiffHours = Math.abs(diffHours)
    const absDiffDays = Math.abs(diffDays)
    
    if (absDiffMinutes < 1) return '刚刚'
    if (absDiffMinutes < 60) return `${absDiffMinutes}分钟前`
    if (absDiffHours < 24) return `${absDiffHours}小时前`
    if (absDiffDays < 7) return `${absDiffDays}天前`
    if (absDiffDays < 30) return `${Math.floor(absDiffDays / 7)}周前`
    if (absDiffDays < 365) return `${Math.floor(absDiffDays / 30)}个月前`
    return `${Math.floor(absDiffDays / 365)}年前`
  }
  
  // 未来时间
  if (diffMinutes < 60) return `${diffMinutes}分钟后`
  if (diffHours < 24) return `${diffHours}小时后`
  if (diffDays < 7) return `${diffDays}天后`
  if (diffDays < 30) return `${Math.floor(diffDays / 7)}周后`
  if (diffDays < 365) return `${Math.floor(diffDays / 30)}个月后`
  return `${Math.floor(diffDays / 365)}年后`
}

/**
 * 统一的日期状态判断（修复版本）
 * @param date 日期对象或字符串
 * @returns 日期状态
 */
export function getDateStatus(date: string | Date): 'overdue' | 'today' | 'tomorrow' | 'upcoming' {
  if (!date) return 'upcoming'
  
  const dateObj = typeof date === 'string' ? new Date(date) : date
  
  if (isNaN(dateObj.getTime())) {
    return 'upcoming'
  }
  
  // 统一使用日期比较，忽略具体时间
  const now = new Date()
  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate())
  const dueDateOnly = new Date(dateObj.getFullYear(), dateObj.getMonth(), dateObj.getDate())
  
  const diffDays = Math.ceil((dueDateOnly.getTime() - today.getTime()) / (24 * 60 * 60 * 1000))
  
  if (diffDays < 0) return 'overdue'
  if (diffDays === 0) return 'today'
  if (diffDays === 1) return 'tomorrow'
  return 'upcoming'
}

/**
 * 获取日期状态的中文描述
 * @param date 日期对象或字符串
 * @returns 中文状态描述
 */
export function getDateStatusText(date: string | Date): string {
  const status = getDateStatus(date)
  
  switch (status) {
    case 'overdue': return '已过期'
    case 'today': return '今天到期'
    case 'tomorrow': return '明天到期'
    case 'upcoming': return formatShortDate(date)
    default: return '未知状态'
  }
}

/**
 * 获取日期状态的样式类名
 * @param date 日期对象或字符串
 * @param completed 任务是否已完成
 * @returns CSS类名
 */
export function getDateStatusStyle(date: string | Date, completed: boolean = false): string {
  const status = getDateStatus(date)
  
  if (completed) {
    return status === 'overdue' 
      ? 'bg-amber-100 text-amber-700' 
      : 'bg-green-100 text-green-700'
  }
  
  switch (status) {
    case 'overdue': return 'bg-red-100 text-red-700 border-red-200'
    case 'today': return 'bg-orange-100 text-orange-700 border-orange-200'
    case 'tomorrow': return 'bg-blue-100 text-blue-700 border-blue-200'
    case 'upcoming': return 'bg-blue-100 text-blue-700 border-blue-200'
    default: return 'bg-blue-100 text-blue-700 border-blue-200'
  }
}

/**
 * 获取日期状态的样式和紧急程度信息
 * @param date 日期对象或字符串
 * @param completed 任务是否已完成
 * @returns 包含样式和紧急程度的对象
 */
export function getDateStatusInfo(date: string | Date, completed: boolean = false): { style: string, urgent: boolean } {
  const status = getDateStatus(date)
  
  if (completed) {
    return {
      style: status === 'overdue' 
        ? 'bg-amber-100 text-amber-700' 
        : 'bg-green-100 text-green-700',
      urgent: false
    }
  }
  
  switch (status) {
    case 'overdue': 
      return { style: 'bg-red-100 text-red-700 border-red-200', urgent: true }
    case 'today': 
      return { style: 'bg-orange-100 text-orange-700 border-orange-200', urgent: true }
    case 'tomorrow': 
      return { style: 'bg-blue-100 text-blue-700 border-blue-200', urgent: false }
    case 'upcoming': 
      return { style: 'bg-blue-100 text-blue-700 border-blue-200', urgent: false }
    default: 
      return { style: 'bg-blue-100 text-blue-700 border-blue-200', urgent: false }
  }
}

/**
 * 获取时间标签的完整信息（文本、样式、图标、紧急程度）
 * @param task 任务对象
 * @returns 时间标签信息对象
 */
export function getTimeLabelInfo(task: any): { text: string, color: string, icon: any, urgent: boolean } | null {
  // 如果任务已完成，显示完成状态标签
  if (task.completed) {
    if (!task.dueDate) {
      return {
        text: '已完成',
        color: 'bg-green-100 text-green-700 border-green-200',
        icon: 'CheckCircle',
        urgent: false
      }
    }
    
    const now = new Date()
    const dueDate = new Date(task.dueDate)
    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate())
    const dueDateOnly = new Date(dueDate.getFullYear(), dueDate.getMonth(), dueDate.getDate())
    
    const diffDays = Math.ceil((dueDateOnly.getTime() - today.getTime()) / (24 * 60 * 60 * 1000))
    
    if (diffDays < 0) {
      return {
        text: '延迟完成',
        color: 'bg-amber-100 text-amber-700 border-amber-200',
        icon: 'Clock',
        urgent: false
      }
    } else {
      return {
        text: '按时完成',
        color: 'bg-green-100 text-green-700 border-green-200',
        icon: 'CheckCircle',
        urgent: false
      }
    }
  }
  
  // 未完成任务的时间标签逻辑
  if (!task.dueDate) return null
  
  const now = new Date()
  const dueDate = new Date(task.dueDate)
  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate())
  const dueDateOnly = new Date(dueDate.getFullYear(), dueDate.getMonth(), dueDate.getDate())
  
  const diffDays = Math.ceil((dueDateOnly.getTime() - today.getTime()) / (24 * 60 * 60 * 1000))
  
  if (diffDays < 0) {
    return {
      text: `逾期${Math.abs(diffDays)}天`,
      color: 'bg-red-100 text-red-700 border-red-200',
      icon: 'AlertCircle',
      urgent: true
    }
  } else if (diffDays === 0) {
    return {
      text: '今天到期',
      color: 'bg-orange-100 text-orange-700 border-orange-200',
      icon: 'Clock',
      urgent: true
    }
  } else if (diffDays === 1) {
    return {
      text: '明天到期',
      color: 'bg-blue-100 text-blue-700 border-blue-200',
      icon: 'Calendar',
      urgent: false
    }
  } else if (diffDays <= 7) {
    return {
      text: `${diffDays}天后到期`,
      color: 'bg-blue-100 text-blue-700 border-blue-200',
      icon: 'Calendar',
      urgent: false
    }
  } else {
    return {
      text: formatLocalDate(task.dueDate),
      color: 'bg-gray-100 text-gray-700 border-gray-200',
      icon: 'Calendar',
      urgent: false
    }
  }
}

/**
 * 判断是否为今天
 * @param date 日期对象或字符串
 * @returns 是否为今天
 */
export function isToday(date: string | Date): boolean {
  return getDateStatus(date) === 'today'
}

/**
 * 判断是否为明天
 * @param date 日期对象或字符串
 * @returns 是否为明天
 */
export function isTomorrow(date: string | Date): boolean {
  return getDateStatus(date) === 'tomorrow'
}

/**
 * 判断是否已过期
 * @param date 日期对象或字符串
 * @returns 是否已过期
 */
export function isOverdue(date: string | Date): boolean {
  return getDateStatus(date) === 'overdue'
}

/**
 * 获取时间上下文信息（用于AI分析）
 * @param createdAt 创建时间
 * @param dueDate 截止时间
 * @returns 时间上下文对象
 */
export function getTimeContext(createdAt: string | Date, dueDate?: string | Date | null) {
  const created = typeof createdAt === 'string' ? new Date(createdAt) : createdAt
  const now = new Date()
  
  // 计算任务存在时间
  const existDays = Math.floor((now.getTime() - created.getTime()) / (24 * 60 * 60 * 1000))
  
  let urgency: 'low' | 'medium' | 'high' = 'low'
  let timeSpan = '无期限'
  let context = '任务无截止时间'
  
  if (dueDate) {
    const due = typeof dueDate === 'string' ? new Date(dueDate) : dueDate
    getDateStatus(due) // 调用函数但不存储结果
    
    // 统一的日期比较逻辑
    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate())
    const dueDateOnly = new Date(due.getFullYear(), due.getMonth(), due.getDate())
    const diffDays = Math.ceil((dueDateOnly.getTime() - today.getTime()) / (24 * 60 * 60 * 1000))
    
    if (diffDays < 0) {
      urgency = 'high'
      timeSpan = `逾期${Math.abs(diffDays)}天`
      context = `任务已逾期${Math.abs(diffDays)}天，需要立即处理`
    } else if (diffDays === 0) {
      urgency = 'high'
      timeSpan = '今天到期'
      context = '任务今天到期，请优先处理'
    } else if (diffDays === 1) {
      urgency = 'medium'
      timeSpan = '明天到期'
      context = '任务明天到期，建议今天完成'
    } else if (diffDays <= 3) {
      urgency = 'medium'
      timeSpan = `${diffDays}天后到期`
      context = `任务${diffDays}天后到期，需要安排时间处理`
    } else {
      urgency = 'low'
      timeSpan = `${diffDays}天后到期`
      context = `任务${diffDays}天后到期，可以合理安排时间`
    }
  }
  
  return {
    urgency,
    timeSpan,
    context,
    existDays,
    status: dueDate ? getDateStatus(dueDate) : null
  }
}

/**
 * 创建今天的日期字符串（用于快速创建任务）
 * @returns 今天的日期字符串 YYYY-MM-DD
 */
export function getTodayString(): string {
  const today = new Date()
  return today.toISOString().split('T')[0]
}

/**
 * 创建明天的日期字符串（用于快速创建任务）
 * @returns 明天的日期字符串 YYYY-MM-DD
 */
export function getTomorrowString(): string {
  const tomorrow = new Date()
  tomorrow.setDate(tomorrow.getDate() + 1)
  return tomorrow.toISOString().split('T')[0]
}

/**
 * 创建下周的日期字符串（用于快速创建任务）
 * @returns 下周同一天的日期字符串 YYYY-MM-DD
 */
export function getNextWeekString(): string {
  const nextWeek = new Date()
  nextWeek.setDate(nextWeek.getDate() + 7)
  return nextWeek.toISOString().split('T')[0]
}

// 统一的TimeUtils对象导出（兼容现有代码）
export const TimeUtils = {
  formatDate: formatLocalDate,
  formatTime: formatLocalTime,
  formatDateTime: formatLocalDateTime,
  formatRelativeTime,
  parseDate: (date: string | Date) => typeof date === 'string' ? new Date(date) : date,
  addDays: (date: Date, days: number) => {
    const result = new Date(date)
    result.setDate(result.getDate() + days)
    return result
  },
  getDaysDiff: (date1: Date, date2: Date) => {
    const diffTime = Math.abs(date2.getTime() - date1.getTime())
    return Math.ceil(diffTime / (1000 * 60 * 60 * 24))
  },
  isToday,
  isTomorrow,
  isOverdue,
  isFuture: (date: string | Date) => {
    const status = getDateStatus(date)
    return status === 'upcoming' || status === 'tomorrow'
  },
  getTimeContext
}